Hi CJ,Thanks for your feedback.
I improved count_letters by reducing time complexity from O(n²) to O(n).

Previously, for each character in the string (O(n)), the code performed a membership check on the entire string (O(n)), resulting in O(n²) complexity.

By precomputing a set of all lowercase characters once (O(n)) and using O(1) set lookups inside the loop, the overall complexity is reduced to O(n) .

Can you also do a complexity analysis for find_longest_common_prefix?

The time complexity of find_longest_common_prefix now is O(n log n + n · m), where n is the number of strings and m is the average length of a string.
Sorting the strings takes O(n log n), and then comparing only adjacent strings takes O(n · m) in the worst case.

How does the program determine the order between two strings? Is the performance affected by string length when we compare two strings? If we take into account m, then the sorting complexity is no longer just O(nlogn).

Thanks for your feedback!
The ordering between two strings during sorting is determined lexicographically in Python, by comparing characters one by one until a difference is found or one string ends.
Comparing two strings therefore takes O(m) time in the worst case, where m is the string length.

Since sorting performs O(n log n) such comparisons, the actual cost of sorting strings is O(n log n · m), not just O(n log n).
After sorting, comparing adjacent strings takes O(n · m) in the worst case.

Thus, the overall time complexity is:

O(n log n · m)

Spot on.